package net.blank.effect.sequenceBmp
{
	import flash.display.Bitmap;
	import flash.events.TimerEvent;
	import flash.utils.Timer;
	
	import net.blank.commonInterface.IDestructible;
	import net.blank.commonInterface.IRecyclable;
	
	/**
	 * 序列图像播放器
	 * @author blank
	 * 
	 */
	public class BMDSequencePlayer extends Bitmap implements IDestructible,IRecyclable
	{
		/**
		 * 帧图像重绘方式-基于第一帧
		 */
		public static const REDRAW_TYPE_BASE_FIRST_FRAME:int=1;
		
		/**
		 * 帧图像重绘方式-普通
		 */
		public static const REDRAW_NORMAL:int=2;
		
		/**
		 * 图像帧列表
		 */
		private var _frames:Vector.<BMDFrame>;
		
		/**
		 * 帧播放计时器
		 */
		private var timer:Timer;
		
		/**
		 * 对于当前图像序列帧的索引
		 */
		private var index:uint;
		
		/**
		 * 帧图像重绘方式
		 */
		private var _redrawType:int;
		
		/**
		 * 已经被摧毁
		 */
		private var _destroyed:Boolean=false;
		
		/**
		 * 序列图像播放器
		 * @param frames
		 * @param pixelSnapping
		 * @param smoothing
		 * 
		 */
		public function BMDSequencePlayer(frames:Vector.<BMDFrame>=null, pixelSnapping:String="auto", smoothing:Boolean=false){
			super(null, pixelSnapping, smoothing);
			
			_frames=frames;
			timer=new Timer(0,0);
		}
		
		/**
		 * 计时器事件,绘制帧图像
		 * @param evt
		 * 
		 */
		private function timerHandler(evt:TimerEvent):void{
			if(index >= _frames.length){
				index=0;
			}
			
			timer.delay = _frames[index].keepTime;
			
			switch(_redrawType){
				case REDRAW_TYPE_BASE_FIRST_FRAME:
					if(!index){
						bitmapData = _frames[ 0 ].bitmapData.clone();
					}
					bitmapData.draw(_frames[index].bitmapData );
					break
				default:
				case REDRAW_NORMAL:
					bitmapData = _frames[index].bitmapData;
					break;
			}
			index++;
		}
		
		/**
		 * 开始播放
		 * @param frames 序列化帧图像列表
		 * 
		 */
		public function play(frames:Vector.<BMDFrame>=null):void{
			if(frames){
				if(_frames && timer.running && frames != _frames){
					index=0;
					
					stop();
				}
				_frames=frames;
			}
			
			if(_frames && _frames.length){
				if(!timer.running){
					timer.addEventListener(TimerEvent.TIMER,timerHandler);
					timer.start();
				}
			}else{
				throw new Error("没有可播放的帧序列");
			}
		}
		
		/**
		 * 停止播放
		 * 
		 */
		public function stop():void{
			if(timer.running){
				timer.stop();
				timer.delay=0;
				
				timer.removeEventListener(TimerEvent.TIMER,timerHandler);
			}
		}
		
		/**
		 * 跳转到指定帧开始播放
		 * @param frameNum 帧编号(第1帧的帧编号为1)
		 * 
		 */
		public function gotoAndPlay(frameNum:int):void{
			if(frameNum >= 1 && frameNum <= _frames.length){	
				if(frameNum == index){
					return;
				}
				index = frameNum - 1;
				
				switch(_redrawType){
					case REDRAW_TYPE_BASE_FIRST_FRAME:
						bitmapData = _frames[0].bitmapData.clone();
						bitmapData.draw(_frames[concat(index)].bitmapData);
						break
					case REDRAW_NORMAL:
						bitmapData = _frames[index].bitmapData;
						break;
				}
				
				if(!timer.running){
					timer.addEventListener(TimerEvent.TIMER,timerHandler);
					timer.start();
				}
				
			}else{
				throw new RangeError ("指定的帧编号错误,应该介于 1 到" + _frames.length + "之间");
			}
		}
		
		/**
		 * 跳转到指定帧并停止
		 * @param frameNum 帧编号(第1帧的帧编号为1)
		 * 
		 */
		public function gotoAndStop(frameNum:int):void{
			if(frameNum > 0 && frameNum <= _frames.length){
				if(frameNum == index){
					return;
				}
				index = frameNum -1;
				
				switch(_redrawType){
					case REDRAW_TYPE_BASE_FIRST_FRAME:
						bitmapData = _frames[0].bitmapData.clone();
						bitmapData.draw(_frames[concat(index)].bitmapData);
						break
					case REDRAW_NORMAL:
						bitmapData = _frames[index].bitmapData;
						break;
				}
				
				stop();
			}else{
				throw new RangeError ("指定的帧编号错误,应该介于 1 到" + _frames.length + "之间");
			}
		}
		
		/**
		 * 
		 * @param endIndex
		 * @return 
		 * 
		 */
		private function concat(endIndex:int):int{	
			bitmapData.lock();
			for(var i:int = 0; i< endIndex; i++){
				bitmapData.draw (_frames[i].bitmapData);
			}
			bitmapData.unlock();
			
			return i;
		}
		
		/**
		 * 序列帧
		 * @param value
		 * 
		 */
		public function set frames(value:Vector.<BMDFrame>):void{
			if(value != _frames){
				_frames=value;
				
				index=0;
			}
		}
		public function get frames():Vector.<BMDFrame>{
			return _frames;
		}
		
		/**
		 * 当前帧编号(第1帧的帧编号为1)
		 * @return 
		 * 
		 */
		public function get currentFrameNum():int{
			return index + 1;
		}
		
		/**
		 * 当前帧
		 * @return 
		 * 
		 */
		public function get currentFrame():BMDFrame{
			return _frames[index + 1];
		}
		
		/**
		 * 总帧数
		 * @return 
		 * 
		 */
		public function get totalFrameNum():int{
			return _frames.length;
		}
		
		/**
		 * 帧重绘方式
		 * @param value
		 * 
		 */
		public function set redrawType(value:int):void{
			_redrawType=value;
		}
		public function get redrawType():int{
			return _redrawType;
		}
		
		public function get destroyed():Boolean{
			return _destroyed;
		}
		
		public function destroy():void{
			stop();
			_frames=null;
			
			_destroyed=true;
		}
		
		public function reset():void{
			stop();
			_frames=null;
		}
	}
}